package com.mhy.netsafe.main.activity;

import android.Manifest;
import android.os.Bundle;
import android.util.Log;

import com.mhy.netsafe.MyApplication;
import com.mhy.netsafe.R;
import com.mhy.netsafe.base.BaseActivity;
import com.mhy.netsafe.db.LoginCacheDao;
import com.mhy.netsafe.utils.cache.LoginCache;
import com.mhy.netsafe.utils.manager.Okhttp3Manager;
import com.tbruyelle.rxpermissions2.Permission;
import com.tbruyelle.rxpermissions2.RxPermissions;

import org.greenrobot.greendao.query.Query;
import org.greenrobot.greendao.query.QueryBuilder;

import java.util.ArrayList;
import java.util.List;

import io.reactivex.functions.Consumer;

public class MainActivity extends BaseActivity {
LoginCacheDao userDao;
    private static final String TAG ="Main" ;
    private Okhttp3Manager okhttp3Manager;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        requestPermissions();
        // 获取UserDao对象
        userDao = MyApplication.getInstance().getmDaoSession().getLoginCacheDao();
        // onCreate()方法的代码更改如下
        userDao.deleteAll();// 保持表中的数据记录纯净，在此便于演示；按需添加
//        insertMany();
//        deleteByName();
//        queryList() ;
    }
    // 打印数据库表中的记录
    private void queryList() {
        String result = "显示结果为：";
        // 获得表中的所有记录
        List<LoginCache> users = userDao.loadAll();
        int i = 0;
        for (LoginCache user : users) {
            i++;
            String res = result + "i=" + i + ",id:" + user.getId() + ",name:" + user.getUserName() + ",code:" + user.getUserCode();
            Log.e("TAG", res);
        }
    }
 /*   long insert(T entity)：插入指定实体，entity即实体对象
    void insertInTx(T... entities)：插入多个实体，参数可为List集合
    long insertOrReplace(T entity)：插入或替换指定实体
    void insertOrReplaceInTex(T... entities)：插入或替换指定实体，参数可为List集合*/
    //单条增
    private void insterOne() {
        LoginCache user1 = new LoginCache();
        user1.setUserName("孙悟空");
        user1.setUserCode("001");
        user1.setPassWord("花果山水帘洞");
        userDao.insert(user1);
    }
//    多条记录添加
    private void insertMany() {
        List<LoginCache> users = new ArrayList<>();

        LoginCache user1 = new LoginCache();
        user1.setUserName("孙悟空");
        user1.setUserCode("001");
        user1.setPassWord("花果山水帘洞");

        LoginCache user2 = new LoginCache();
        user2.setUserName("猪八戒");
        user2.setUserCode("002");
        user2.setPassWord("高老庄");

        LoginCache user3 = new LoginCache();
        user3.setUserName("沙悟净");
        user3.setUserCode("003");
        user3.setPassWord("流沙河");

        LoginCache user4 = new LoginCache();
        user4.setUserName("黑熊怪");
        user4.setUserCode("004");
        user4.setPassWord("黑风山");

        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);

        userDao.insertInTx(users);
    }
/*    删除
    void delete(T entity)：删除指定的实体
    void deleteInTx(T... entities)：删除多个实体，参数可以是List集合
    void deleteAll()：删除所有记录
    void deleteByKey(K key)：删除指定主键对应的实体*/
    private void deleteByName(){
        QueryBuilder qb=userDao.queryBuilder();
        // 查询想要删除的记录；根据场景需要，记得判空
        List<LoginCache> userList=qb.where(LoginCacheDao.Properties.UserName.eq("猪八戒")).list();
        for(LoginCache user:userList){
            // 每次删除一条记录
            userDao.delete(user);
        }
        // 一次删除多条记录
        // userDao.deleteInTx(userList);
    }
/* 修改
   void update(T entity)：修改一个被查询出来的实体
    void updateInTx(T... entities)：修改多个被查询出来的实体，这些实体可被放在一个List中*/
    private void updateUser(){
        LoginCache user=userDao.queryBuilder().where(LoginCacheDao.Properties.UserName.eq("孙悟空")).build().unique();
        // 修改使用setter方法
        user.setPassWord("天宫蟠桃园");
        userDao.update(user);
    }


/* DAO查询
    java.util.List<T> loadAll：查找所有记录，返回List集合
    T load(K key)：按主键值查询一条记录，返回实体类对象
    T loadByRowId(long rowId)：按行id查询一条记录，返回实体类对象
    注意：
    如果主键id是自动增长。则load()方法和loadByRowId()方法作用相同，即key值与rowId值相同
    list()方法返回所有值，unique()方法返回唯一值*/
    private void loadOneById() {
        // 要注意”6“是否存在
//        LoginCache user = LoginCacheDao.load(new Long((long) 6));
        LoginCache user = userDao.loadByRowId(new Long((long) 6));
        Log.d("TAG", "name:" + user.getUserName());
    }
    /*QueryBuilder查询
    QueryBuilder<T> where(WhereCondition cond, whereCondition... condMore)：条件查询，参数之间本质是AND连接
    QueryBuilder<T> whereOr(WhereCondition cond, whereCondition... condMore)：条件查询，参数之间本质是OR连接
    QueryBuilder<T> distinct()：去除重复记录，例如使用联合查询时
    QueryBuilder<T> limit(int limit)：限制记录返回数，用于分页
    QueryBuilder<T> offset(int offset)：偏移结果起始位，即从第几条开始取limit()中限制的记录数，配合limit()使用
    QueryBuilder<T> orderAsc(Property... properties)：升序排列
    QueryBuilder<T> orderDesc(Property... properties)：降序排列
    WhereCondition and(WhereCondition cond1, WhereCondition cond2, whereCondition... condMore)：添加条件，AND连接
    WhereCondition or(WhereCondition cond1, WhereCondition cond2, whereCondition... condMore)：添加条件，OR连接
*/
    private void queryQB() {
        QueryBuilder qb = userDao.queryBuilder();
        // 查询名字带有“悟”字的，并且按照属性usercode进行降序排列
//        List<LoginCache> userList=qb.where(LoginCacheDao.Properties.UserName.like("%悟%"))
//                .orderDesc(LoginCacheDao.Properties.Usercode).list();
        //查询名字带有“悟”字的，而且地址时“流沙河”的或者是带有“山”字的且usercode==001的
        List<LoginCache> users = qb.where(LoginCacheDao.Properties.UserName.like("%悟%"),
                qb.or(LoginCacheDao.Properties.UserCode.eq("流沙河"),
                        qb.and(LoginCacheDao.Properties.UserCode.like("%山%"),
                                LoginCacheDao.Properties.UserCode.eq("001")))).list();
        if (users != null) {
            int i = 0;
            for (LoginCache user : users) {
                i++;
                String res = "i=" + i + ",id:" + user.getId() + ",name:" + user.getUserName() + ",address:" + user.getPassWord();
                Log.d("TAG", res);
            }
        }
    }
    // 按名字查询
    private void queryOneByName() {
        LoginCache user = userDao.queryBuilder().where(LoginCacheDao.Properties.UserName.eq("孙悟空")).build().unique();
        if (user != null) {
            Log.e("添加一条记录：id:" + user.getId()  ,"地址：" + user.getPassWord());
        }
    }
    // 分页示例
    // limit(3)：查询3条记录，offset(1):从第2条记录开始，0表示从第一条记录开始
    // 可用于分页，即limit(3)表示一页有3条记录，可用于显示一页的记录
//    List<LoginCache> users = userDao.queryBuilder().limit(3).offset(1).list();
/*
    Query重复查询
    Query<T> build()：获得Query对象
    Query<T> setParameter(int index, java.lang.Object parameter)：设置查询参数
*/
    private void queryRepeat(){
        Query query=userDao.queryBuilder().where(LoginCacheDao.Properties.UserName.like("%悟%"),
                LoginCacheDao.Properties.UserCode.like("%山%")).build();
        // 重新设置参数
        query.setParameter(0,"%怪%");
        query.setParameter(1,"%洞%");
        List<LoginCache> userList=query.list();
    }

 /*   SQL查询
    java.util.List<T> queryRaw(java.lang.String where, java.lang.String... selectionArg)：直接用sql语句获得查询List对象
    Query<T> queryRawCreate((java.lang.String where, java.lang.Object... selectionArg)：获得Query对象，Query.list()获得List对象
    注意：sql语句中的列名是数据表列名，而不是实体类的属性名。
    */
    private void querySql(){
//        List<LoginCache> userList=LoginCacheDao.queryRaw("where  username like '%悟%'");
        Query query=userDao.queryRawCreate("where  username like '%悟%'");
        List<LoginCache> userList=query.list();
        queryView(userList);
    }

    private void queryView(List<LoginCache> userList) {
        Log.e("list",userList.get(0).getUserName());
    }
/*
    补充
    eq：==（等于）
    notEq：！=（不等于）
    gt：>（大于）
    It：<（小于）
    ge：>=（大于等于）
    le：<=（小于等于）
    like：包含，需要与%(_)配合使用
    between：在两者之间
    in：在某些值内
    notIn：不在某些值内
    注意：在代码中加入以下两行代码，即可在Android Monitor窗口中看到生成的sql语句，以及sql语句中的值。
// 在onCreate()中添加
    QueryBuilder.LOG_SQL = true;        // 显示sql语句
    QueryBuilder.LOG_VALUES = true; // 显示sql语句中的值*/

    @Override
    protected void initData() {

    }

    @Override
    protected void initViews() {

    }

    private void requestPermissions() {
        RxPermissions rxPermission = new RxPermissions(this);
        rxPermission
                .requestEach(Manifest.permission.ACCESS_FINE_LOCATION,
                        Manifest.permission.WRITE_EXTERNAL_STORAGE,
                        Manifest.permission.READ_CALENDAR,
                        Manifest.permission.READ_CALL_LOG,
                        Manifest.permission.READ_CONTACTS,
                        Manifest.permission.READ_PHONE_STATE,
                        Manifest.permission.READ_SMS,
                        Manifest.permission.RECORD_AUDIO,
                        Manifest.permission.CAMERA,
                        Manifest.permission.CALL_PHONE,
                        Manifest.permission.SEND_SMS)
                .subscribe(new Consumer<Permission>() {
                    @Override
                    public void accept(Permission permission) throws Exception {
                        if (permission.granted) {
                            // 用户已经同意该权限
                            Log.d(TAG, permission.name + " is granted.");
                        } else if (permission.shouldShowRequestPermissionRationale) {
                            // 用户拒绝了该权限，没有选中『不再询问』（Never ask again）,那么下次再次启动时。还会提示请求权限的对话框
                            Log.d(TAG, permission.name + " is denied. More info should be provided.");
                        } else {
                            // 用户拒绝了该权限，而且选中『不再询问』
                            Log.d(TAG, permission.name + " is denied.");
                        }
                    }
                });


    }
}
